#include "Robot.h"
#include "EtatRobotAVide.h"



	    void Robot::_avancer(int x, int y){
			_position->setx(x);
			_position->sety(y);
		}
		void Robot::_tourner(string direction){
			_direction = direction;
		}
		void Robot::_saisir(Objet * objet){
			_objet = objet;
		}
		void Robot::_poser(){
			_objet = NULL;
		}
		int Robot::_peser(){
			return _objet->getPoids();
		}
		void Robot::_rencontrerObstacle(Obstacle * o){
			_obstacle = o;
		}
		int Robot::_evaluerObstacle(){
			return _obstacle->getHauteur();
		}

		void Robot::avancer(int x, int y){
			try {
				getCurrentState()->avancer();
				_avancer(x,y);
				afficher();
			} catch (const exception& e){
				cout << "Impossible d'avancer dans cet état" << endl;
			}
		}
		void Robot::tourner(string direction){
			try {
				getCurrentState()->tourner();
				_tourner(direction);
				afficher();
			} catch (const exception& e){
				cout << "Impossible de tourner dans cet état" << endl;
			}
		}
		void Robot::saisir(Objet * objet){
			try {
				getCurrentState()->saisir();
				_saisir(objet);
				afficher();
			} catch (const exception& e){
				cout << "Impossible de saisir dans cet état" << endl;
			}
		}
		void Robot::poser(){
			try {
				getCurrentState()->poser();
				_poser();
				afficher();
			} catch (const exception& e){
				cout << "Impossible de poser dans cet état" << endl;
			}
		}

		int Robot::peser(){
			try {
				getCurrentState()->peser();
				return _peser();
			} catch (const exception& e){
				cout << "Impossible de peser dans cet état" << endl;
				return -1;
			}
			
		}
		void Robot::rencontrerObstacle(Obstacle * o){
			try {
				getCurrentState()->rencontrerObstacle();
				_rencontrerObstacle(o);
				afficher();
			} catch (const exception& e){
				cout << "Impossible de rencontrer un obstacle dans cet état" << endl;
			}
		}
		
		int Robot::evaluerObstacle(){
			try {
				getCurrentState()->evaluerObstacle();
				return _evaluerObstacle();
			} catch (const exception& e){
				cout << "Impossible d'évaluer un obstacle s'il n'y a pas d'obstacle en face" << endl;
				return -1;
			}
		}
		void Robot::figer(){
			try {
				getCurrentState()->figer();
				afficher();
			} catch (const exception& e){
				cout << "Impossible de figer dans cet état" << endl;
			}
		}
		void Robot::repartir(){
			try {
				getCurrentState()->repartir();
				afficher();
			} catch (const exception& e){
				cout << "Impossible de repartir dans cet état" << endl;
			}
		}
		
		void Robot::changerEtat(EtatRobot * nouvelEtat){
			_etat = nouvelEtat;
		}

		void Robot::setAncienEtat(EtatRobot * nouvelEtat){
			_ancienEtat = nouvelEtat;
		}

		EtatRobot * Robot::getCurrentState(){
			return _etat;
		}

		EtatRobot * Robot::getAncienEtat(){
			if(_ancienEtat != NULL){
				return _ancienEtat;
			}
			return EtatRobotAVide::getInstance(this);
		}


Robot::Robot() : _direction("N") {
	_ancienEtat = NULL;
	_etat = EtatRobotAVide::getInstance(this);
	_objet = NULL;
	_obstacle = NULL;
	_position = new Position();
}

void Robot::setPosition(Position * p) {
	_position = p;
}

void Robot::setObjet(Objet * o) {
	_objet = o;
}

void Robot::setObstacle(Obstacle* o) {
	_obstacle = o;
}

void Robot::setDirection(string d) {
	_direction = d;
}

Position *Robot :: getPosition(){
	return _position;
}

Obstacle* Robot::getObstacle() {
	return _obstacle;
}

Objet * Robot::getObjet() {
	return _objet;
}

string Robot::getDirection() {
	return _direction;
}
